Mobiclic 71/MOBICLIC 71.ISO/mac/DATA/COMMUN/temp0001/00221_Script_SCRIPTS_GENE_JLM_01

Text File | 2004-12-05 | 66KB | 1,989 lines

--scripts gΘnΘraux pour Mobiclic nouvelle formule by ⌐Time line/jl moreau 2003,2004
-------------------------------------------------
on hide_title--obsolΦte
  nothing
end
----------------
on LOAD_MOBIDATA
  if the runMode = "author" and lien() = ":" then
    importFileInto member("MOBIDATA"), "@//COMMUN/DATABASE/MOBIDATA.txt"
    castLib("MOBI_MATOS").save()
  end if
end
------------------
on SOSMIAW
  global gL_Zap
  temp = the windowlist.duplicate()
  N = count(temp)
  if N = 0 then exit
  repeat with i = 1 to N
    target = temp[i].name
    window(target).close()
    window(target).forget()
    if target = "ZAPETTE"  then gL_Zap[2] = 0
  end repeat
  clearglobals()
end
-----------------------------------
on goOtherRub  RUB, NoSousRub, ZELABEL
  --envoie d'un dir d'une rubrique α un dir d'une autre rubrique
  target = "@//"&RUB&"/"&RUB.char[1..4]&gimme2digits(NoSousRub)
  case(the paramCount) of
    2:-- on lance le dir α son dΘbut
      go movie target
    3:-- on envoie α un label du dir α l'ouverture
      go ZELABEL of movie target
  end case
end
----------------
on goSameRub SUFFIXE, ZELABEL
  --envoie d'un dir d'une rubrique α un autre dir de la mΩme rubrique
  target = "@/"&localparam("COORD",5)&gimme2digits(SUFFIXE)
  case(the paramCount) of
    1:
      go movie target
    2:
      go ZELABEL of movie target
  end case
end
-----------------------
on sauteLabel MARQUEUR
  --permet d'envoyer la tΩte de lecture α la frame suivant un label en enregistrant
  --dans la globale gze_Label le pasage α ce label
  global gze_Label
  gze_Label = MARQUEUR
  go label(MARQUEUR) + 1
end
------------------
on Jump00
  u = zlast()
  if  zNoSRub() = 1 and u.char[1..4] = zAbrev() and extractNo(u) <> 0 then go "ATTENTE"
end
----------------
on KURSOR NomCurseur
  cursor[member(NomCurseur).number,member(NomCurseur&"_MASK").number]
end
------------------
on turndizstuff_Mob WADSPRITE, WADWAY
  case(WADWAY) of
    "ON":
      if sprite(WADSPRITE).left >= 640 then sprite(WADSPRITE).locH = sprite(WADSPRITE).locH - 800
    "OFF":
      if sprite(WADSPRITE).left < 640 then sprite(WADSPRITE).locH = sprite(WADSPRITE).locH + 800
  end case
end
-------------------------------------------------
on turndizstuff  WADSPRITE, WADWAY
  case(WADWAY) of
    "ON":
      if sprite(WADSPRITE).left >= 800 then sprite(WADSPRITE).locH = sprite(WADSPRITE).locH - 800
    "OFF":
      if sprite(WADSPRITE).left < 800 then sprite(WADSPRITE).locH = sprite(WADSPRITE).locH + 800
  end case
end
-------------------------------------------------
on TDS WADSPRITE, WADWAY
  turndizstuff_Mob(WADSPRITE, WADWAY)
end
-------------------------
on gimme2digits ZENOMBRE
  case(ZENOMBRE) <10 of
    1:
      reponse = "0"&string(ZENOMBRE)
    0:
      reponse = string(ZENOMBRE)
  end case
  return reponse
end
-------------------------------------------------
on tail ZESTRING, NbCHAR
  L = length(ZESTRING)
  return ZESTRING.char[L-NbCHAR + 1..L]
end
---------------------------
on but_tail ZESTRING, NbCHAR
  L = length(ZESTRING)
  return ZESTRING.char[1..L-NbCHAR]
end
-----------------------
on cleanTail CHAINE
  L = length(CHAINE)
  u = L
  repeat while CHAINE.char[u] = RETURN or CHAINE.char[u] = SPACE
    U = U-1
    CHAINE = CHAINE.char[1..U]
  end repeat
  return CHAINE
end
---------------
on gimmezeAlphabet_No WATCHAR
  u = chartoNum(WATCHAR)
  case(u>64 and u < 91) of
    1:-- si c'est une capitale
      reponse = u - 64
    0:
      case(u>96 and u < 123) of
        1: -- si c'est une bas de casse
          reponse = u - 96
        0:
          reponse = 0
      end case
  end case
  return reponse
end
-----------------------------------
on zLOWCASE MOT
  fin = length(MOT)
  reponse = EMPTY
  repeat with i = 1 to fin
    lettre = MOT.char[i]
    code = charToNum(lettre)
    if code <65 or code >90 then--si ca n'est pas une lettre majuscule
      reponse = reponse&lettre---------------on pile la lettre
    else---------------------------si c'est une majuscule
      reponse = reponse&numToChar(code+32)---on pile la minuscule correspondante
    end if
  end repeat
  return reponse
end
-----------------------
on zCAPITAL MOT
  fin = length(MOT)
  reponse = EMPTY
  repeat with i = 1 to fin
    lettre = MOT.char[i]
    code = charToNum(lettre)
    if code <97 or code >122 then--si ca n'est pas une lettre minuscule
      reponse = reponse&lettre---------------on pile la lettre
    else---------------------------si c'est une minuscule
      reponse = reponse&numToChar(code-32)---on pile la majuscule correspondante
    end if
  end repeat
  return reponse
end
-------------------
on byte2Mega NbBYTES
  return float(NbBYTES)/power(2,20)
end
----------------------------------
on JINGLE WATTRACK,WATSOUND, WATMODE
  global gL_Zap
  --joue un son du dossier JINGLES, soit en "direct from disk" (WATMODE = OUT),
  --soit α partir de la distribution JINGLE (WATMODE = IN)
  --avec ajustement des niveaux sonores
  put "son jingle jouΘ:"& WATSOUND
  case(WATMODE) of
    "IN":
      puppetSound WATTRACK, WATSOUND
    "OUT":
      sound playFile WATTRACK, "@//COMMUN/MOBI_JINGLES/"&WATSOUND&".aif"
      repeat with i=1 to 8
        if i<>WATTRACK and gL_Zap[16][i] > 110 then
          sound(i).volume = 50
        end if
      end repeat
  end case
end
-----------------------------------------
on LOWJINGLE WATTRACK,WATSOUND, WATMODE
  --joue un son du dossier JINGLES, soit en "direct from disk" (WATMODE = OUT),
  --soit α partir de la distribution JINGLE (WATMODE = IN)
  --sans ajustement des niveaux sonores
  put "son jingle jouΘ:"& WATSOUND
  case(WATMODE) of
    "IN":
      puppetSound WATTRACK, WATSOUND
    "OUT","O":
      sound playFile WATTRACK, "@//COMMUN/MOBI_JINGLES/"&WATSOUND&".aif"
  end case
end
-----------------------------------------
on gimmeQDraw_Center ZESPRITENo
  --retourne le centre d'une forme QUICKDRAW situΘ sur la piste n░ ZESPRITENo
  return point( (sprite(ZESPRITENo).right+sprite(ZESPRITENo).left )/2, (sprite(ZESPRITENo).Top + sprite(ZESPRITENo).Bottom)/2)
end
----------------------------------------
on locate_QDraw_bycenter ZESPRITENo, WATPLACE
  -- positionne le centre d'un QuickDraw
  zedelta = point(sprite(ZESPRITENo).width/2, sprite(ZESPRITENo).height/2)
  sprite(ZESPRITENo).loc = WATPLACE - zedelta
end
-----------------------------
on lien
  if the platform contains "Win" then
    reponse = "\"
  else
    reponse = ":"
  end if
  return reponse
end
------------------------
on D10--renvoie 1 si la version du player est supΘrieure ou Θgale α celle de Director MX 2004 (version 10)
  mem = the itemDelimiter
  the itemDelimiter = "."
  temp = the productVersion.item[1]
  the itemDelimiter = mem
  if value(temp) >= 10 then
    return 1
  else
    return 0
  end if
end
-----------------------
on zOs
  global gL_MOBIDATA
  temp = gL_MOBIDATA[1][4]
  case(lien()) of
    ":":
      the itemdelimiter = " "
      plateforme = temp.item[1]
      version = temp.item[3]
    "\":
      the itemdelimiter = ","
      plateforme = temp.item[1]
      version = temp.item[2]
  end case

  case(plateforme) of
    "Macintosh":
      the itemdelimiter = "."
      reponse = ["MAC",value(version.item[1])]--ex: ["Mac",10]
    otherwise:
      reponse = [plateforme,value(version)]--ex ["Windows XP",5]
  end case
  the itemdelimiter = ","
  return reponse
end
-----------------------
on ztitre ZUT
  global gpisteTitre
  case (ZUT) of
    0:
      sprite(gpisteTitre).member = "TITRE_NOP"
    otherwise:
      u = "TITRE_"&ZUT
      sprite(gpisteTitre).member = u
  end case
  updateStage
end
-------------------------
on zNoMobi
  global  gL_MOBIDATA
  return gL_MOBIDATA[1][1]
end
-----------------------
on zRub
  return string(localparam("COORD",1))
end
-----------------------
on zNoRub
  return localparam("COORD",2)
end
---------------------
on zfamily
  return localparam("COORD",3)
end
-------------------
on zNbSRub
  return localparam("COORD",4)
end
---------------
on zAbrev
  return localparam("COORD",5)
end
--------------------
on zNoSRub
  return localparam("COORD",6)
end
--------------
on zRacine
  return zAbrev()&gimme2digits(zNoSRub()-1)
end
----------------------
on zLast--renvoie le nom bref du dernier movie prΘcedemment ouvert ex "ARRI03"
  global gL_Zap
  if voidP( gL_Zap) then
    return EMPTY
  else
    return  gL_Zap[11]
  end if
end
----------------
on zVolume NoPISTE
  global gL_Zap
  if voidP( gL_Zap) then
    return EMPTY
  else
    return gL_Zap[16][NoPISTE]
  end if
end
--------------------
on zDumb
  global gL_Zap
  if voidP( gL_Zap) then
    return EMPTY
  else
    return localparam("TOOLS","ZDUMB")
  end if
end
--------------------
on etatDumb
  global gL_Zap
  if voidP( gL_Zap) then
    return EMPTY
  else
    return gL_zap[23]
  end if
end
-----------
on  zmemberName OBJ
  reponse = sprite(OBJ.spriteNum).member.name
  if tail(reponse,2) = "_R" then reponse = but_tail(reponse,2)
  return reponse
end
-----------------------------
on zRub_UserList  MODE -- envoie dans le container "USERS_TANK"(castLib "MOBI_MATOS")
  global gScore_NomFic
  --la liste des joueurs enregistrΘs dans le jeu de cette rubrique
  --stockΘe sur le disque dur
  case(the paramCount) of
    0: --mode ancien( ex: quizz
      gimme_userList("M"&string(zNoMobi())&string(zRub()),"USERS_TANK")
    1:
      case( param(1)) of
        "SCORE":--module d'enregistrement de score
          gimme_userList(gScore_NomFic,"USERS_TANK")
        otherwise:

      end case

  end case
end
----------------------------
on zSaveRub_UsersList ZELIST
  global glocalBUpath
  pipeLine = new(xtra"fileio")-- crΘation d'une instance de l'Xtra File IO
  --
  fileName = glocalBUpath&"MOBICLIC"&lien()&"M"&string(zNoMobi())&string(zRub())&".txt"
  -- crΘe le fichier
  createFile (pipeLine, filename)
  -- ouvre le fichier
  openFile (pipeLine, filename, 0)
  --dΘtruit le fichier deja existant
  delete(pipeLine)
  -- crΘe le fichier
  createFile (pipeLine, filename)
  -- ouvre le fichier
  openFile (pipeLine, filename, 0)
  -- Θcriture de l'acteur
  pipeLine.writeString(string(ZELIST))
  -- fermeture
  closeFile(pipeLine)
  pipeLine = 0
end
--------------------
on participe TARGET
  global  gL_RetourCOUR, gPart_Target
  gL_RetourCOUR = [string(zrub()),zNoSRub()]
  gPart_Target = TARGET
  goOtherRub("COURRIER",0)
end
--------------------
on localParam SUJET, SOUS_SUJET-- SUJET prenant les valeurs "COORD", "NAV", "TOOLS" ou "MISC",SOUS_SUJET Θtant un entier ou "ALL"
  global gL_localdata
  case(SOUS_SUJET = "ALL") of
    1:
      return gL_localdata.getProp(SUJET)
    0:
      case(integerP(SOUS_SUJET)) of
        1:
          return gL_localdata.getProp(SUJET)[SOUS_SUJET]
        0:
          return gL_localdata.getProp(SUJET).getProp(SOUS_SUJET)
      end case
  end case
end
-------------------------
on COMMENT_TANK
  reponse = "LOCAL_COMMENTS"
  return reponse
end
-------------------------------
on windAuga VAR,NOMFEN
  global gL_Zap
  case(D10()) of
    0:-------------------------------------- player crΘΘ avec une version < Director 10
      VAR.windowType = member(NOMFEN&"_MASK")
      VAR.modal = 0
    1:-------------------------------------- player crΘΘ avec une version >=  Director 10
      case(lien()) of
        ":":--------------------------------------- on est sur un Mac
          case(zOs()[2]>=10) of
            1:------------------------------------------- on est sous OsX
              VAR.appearanceOptions.mask = member(NOMFEN&"_MASK")
              VAR.type = #tool
              VAR.appearanceOptions.shadow = TRUE
            0:------------------------------------------- on est sous Classic
              VAR.appearanceOptions.mask = member(NOMFEN&"_MASK")
              --              VAR.type = #tool

          end case
        "\":--------------------------------------- on est sur un Pc
          VAR.type = #tool
          VAR.appearanceOptions.mask = member(NOMFEN&"_MASK")
      end case
  end case
end
------------------------------
on PATCH4_Os9 NOMFEN
  if zOs()[1] = "MAC" and zOs()[2] < 10 then NOMFEN.moveToFront()
end
-------------------------------
on show_RECRE NoRECRE
  x0 = the stageLeft
  y0 = the stageTop
  ze_W = window("RECRE_TEMP")
  ze_W.rect = rect(x0 + 74,y0 + 0, x0 + 566 ,y0 + 450)
  ze_W.filename = "@/RECRE"&gimme2digits(NoRECRE)
  windAuga(ze_W,"RECRE")
  ze_W.title =EMPTY
  ze_W.open()
end
----------------------
on show_ENCADRE NoENCADRE
  x0 = the stageLeft
  y0 = the stageTop
  if D10() then window().new("ENCADRE_TEMP")
  ze_W = window("ENCADRE_TEMP")
  temp = "ENCADRE_"&gimme2digits(NoENCADRE)
  demi_w = member(temp&"_MASK").width/2
  demi_h = member(temp&"_MASK").height/2
  ze_W.rect = rect(x0 + 320 - demi_w,y0 + 240 - demi_h, x0 + 320 + demi_w ,y0 + 240 + demi_h)
  ze_W.filename = "@/ENCA_"&zAbrev()&gimme2digits(NoENCADRE)
  windAuga(ze_W,temp)
  ze_W.title =EMPTY
  ze_W.open()
end
---------------------
on show_COMMENTS TEMP --ouvre la fenΩtre commentaires
  global gL_Zap
  if gL_Zap[30] = 0 then member("DUMB_COMMENT").text = EMPTY
  if gL_Zap[23]= 0 then-- la fenΩtre commentaires n'a pas encore ΘtΘ ni chargΘe, on charge la fenΩtre
    x0 = the stageLeft
    y0 = the stageTop
    if D10() then window().new("COMMENTS")
    gL_Zap[24] = window("COMMENTS")
    gL_Zap[25] = [member("COMMENTS_MASK").width,member("COMMENTS_MASK").height]
    rect_fen = rect(x0 + 2,y0 + 450, x0 +2 + gL_Zap[25][1],y0 + 450 + gL_Zap[25][2])
    gL_Zap[24].rect = rect_fen
    gL_Zap[26] = rect_fen
    gL_Zap[24].filename = "@//COMMUN/MOBI_SOUSTITRAGE"
    windAuga(gL_Zap[24],"COMMENTS")
    gL_Zap[24].title =EMPTY
  end if
  case(gL_Zap[23]) of
    0:-- la fenΩtre commentairesn'a pas encore ΘtΘ ni chargΘe no α fortiori ouverte
      gL_Zap[27] = rect_fen --memorisation de l'emplacement d'ouverture de la fenΩtre commentaires
      gL_Zap[23]= 1
      gL_Zap[24].open()
    -1:-- la fenΩtre commentaires a ΘtΘ chargΘe mais elle est fermΘe actuellemnet
      gL_Zap[23]= 1
      gL_Zap[24].open()
    1:---- fenΩtre commentaires est ouverte, on la rouvre α sa place initiale
      --cela permet de la rΘcupΘrer quand elle est hors Θcran
      gL_Zap[24].rect = gL_zap[26]
      gL_zap[27] = gL_zap[26]
  end case
  tell gL_Zap[24]
    sprite(1).member = "FD_COMMENT_"&gimme2digits(zfamily())
    updatestage
  end tell
end
-------------------------
on show_zapette TEMP --ouvre la fenΩtre tΘlΘcommande
  global gL_Zap
  if gL_Zap[2]= 0 then-- la fenΩtre de la zapette n'a pas encore ΘtΘ ni chargΘe, on charge la fenΩtre
    x0 = the stageLeft
    y0 = the stageTop
    if D10() then window().new("ZAPETTE")
    gL_Zap[1] = window("ZAPETTE")
    gL_Zap[4] = [member("ZAPETTE_MASK").width,member("ZAPETTE_MASK").height]
    rect_zapette = rect(x0,y0 + 480 -gL_Zap[4][2], x0 + gL_Zap[4][1] ,y0 + 480)
    gL_Zap[1].rect = rect_zapette
    gL_Zap[5] = rect_zapette
    gL_Zap[1].filename = "@//COMMUN/MOBI_ZAPETTE"
    windAuga(gL_Zap[1],"ZAPETTE")
    gL_Zap[1].title =EMPTY
  end if
  case(gL_Zap[2]) of
    0:-- la fenΩtre de la zapette n'a pas encore ΘtΘ ni chargΘe ni α fortiori ouverte
      gL_Zap[6] = rect_zapette --memorisation de l'emplacement d'ouverture de la zapette
      gL_Zap[2]= 1
      gL_Zap[1].open()

    -1:-- la fenΩtre de la zapette a ΘtΘ chargΘe mais elle est fermΘe actuellement
      gL_Zap[2]= 1
      gL_Zap[1].open()
      tell gL_Zap[1]
        go "MAJ"
      end tell
    1:---- la fenΩtre de la zapette est ouverte, on la rouvre α sa place initiale
      --cela permet de la rΘcupΘrer quand elle est hors Θcran
      gL_Zap[1].rect = gL_zap[5]
      gL_zap[6] = gL_zap[5]
      tell gL_Zap[1]
        go "MAJ"
      end tell
  end case

end
---------------------
on refresh_zapette
  global gL_Zap
  if gL_Zap[1] = EMPTY then-- pour le mode auteur quand on ouvre directement n'importe quel dir
    show_zapette()
  else
    --
  end if
  tell gL_Zap[1]
    go "MAJ"
  end tell
end
--------------------
on MAJ_zapette--PROCEDURE DE RAFRAICHISEMENT DE LA ZAPETTE
  global gL_localdata, gL_Zap, gL_mobidata,gL_localTEXTES
  tell the stage
    init_localTEXTES()
  end tell
  if gL_Zap[2]= 0 then exit--si la fenΩtre de zappette n'est pas encore ouverte on passe
  gL_Zap[3] = 1--on met α 1 le flag de mise α jour
  NoStyle_zapette= gL_localdata[1][4]
  --  MAJ du fond de la zapette
  sprite(2).member = "FDZAP_"&gimme2digits(localparam("COORD",3))
  --MAJ de la titraille--------------------------------------
  if gL_localTEXTES =[] or voidP(gL_localTEXTES) then
    member("TITRE_RUB").text = EMPTY
  else
    temp = gL_localTEXTES.getaProp("_TITRE")
    if not(zRub() = "CPLUSCLAIR" and  zNoSRub() = 1) then
      tell the stage
        if member(COMMENT_TANK()).text = EMPTY then member("TITRE_RUB").text = EMPTY
        u =  member(COMMENT_TANK()).char[temp[1]..temp[2]]
        if not(voidP(u)) then
          member("TITRE_RUB").text =u
        end if
        member("TITRE_RUB").fontSize = 9
      end tell
    end if
  end if
  --MAJ des boutons de navigation-----------------------------------
  L1 = ["ZNEXT", "ZPREV","ZBEGIN","ZAGAIN","ZPAUSE"]
  temp = localParam("NAV", "ALL")
  repeat with i = 1 to count(L1)
    puppetSprite sprite(gL_Zap[7][i]), FALSE
    if temp.getProp(L1[i]) = -1 then
      sprite(gL_Zap[7][i]).blend = 20
    else
      sprite(gL_Zap[7][i]).blend = 100
    end if
  end repeat
  --MAJ des boutons des utilitaires
  L1 = ["ZHELP","ZDICO","ZINFO","ZDUMB","ZAPHELP"]
  temp = localParam("TOOLS", "ALL")
  repeat with i = 1 to count(L1)
    puppetSprite sprite(gL_Zap[8][i]), FALSE
    if temp.getProp(L1[i]) = -1 then
      sprite(gL_Zap[8][i]).blend = 20
    else
      sprite(gL_Zap[8][i]).blend = 100
    end if
  end repeat
  --MAJ des boutons MISC
  ---------bouton coupe musique
  case(gL_Zap[17]) of
    1:
      --      sprite(gL_Zap[19][4]).member = "BTON_MUSIK_OFF"
      sprite(46).member = "BTON_MUSIK_OFF"
    0:
      --      sprite(gL_Zap[19][4]).member = "BTON_MUSIK_ON"
      sprite(46).member = "BTON_MUSIK_ON"
  end case
  --------VuMETRE
  --  sprite(gL_Zap[19][3]).member = "VU"&gimme2digits(gL_Zap[16][9])
  sprite(45).member = "VU"&gimme2digits(gL_Zap[16][9])
  ---------DIODES
  NbEcrans = localParam("COORD",4) --on rΘcupΦre le nombre de dirs de la rubrique
  repeat with i = 1 to 12-----------on rend visibles seulement les diodes associΘes aux Θcrans de la rubrique
    u = gL_zap[15] + i -1
    if i <= NbEcrans then
      sprite(u).blend = 100
    else
      sprite(u).blend = 0
    end if
  end repeat

  NoRub = gL_mobiDATA[3].getPos(zabrev())
  temp = gimmeDATA([4 + 2*NoRub])[1]
  repeat with i = 1 to NbEcrans --masquage des diodes associΘes aux Θcrans rendus non accessibles
    u = gL_zap[15] + i -1
    case(temp[i].getProp("MISC").getprop("ZCLICDIODE")) of
      -1:
        sprite(u).blend = 0
      1:
        sprite(u).blend = 100
    end case
  end repeat

  --  sprite(gL_Zap[15] + 12).left = sprite(gL_Zap[15] + NbEcrans -1).right--ajustement du masque de diodes pour faire apparitre le nombre exact de diodes
  fin = localParam("COORD",4)
  temp = gL_mobidata[4][localParam("COORD",2)-1]
  repeat with i = 1 to fin
    u = gL_zap[15] + i -1
    if temp[i] = 1 then -- si le dir a dΘja ΘtΘ ouvert on illumine la diode correspondante dans la zapppette
      sprite(u).member = "DIODE_ON"
    else------------------ si le dir n'a pas dΘja ΘtΘ ouvert on Θteint la diode correspondante dans la zapppette
      sprite(u).member = "DIODE_OFF"
    end if
  end repeat
  ---------triangle pointeur
  No = localParam("COORD",6)
  flag = localParam("MISC",3)
  if flag = 1 then--si la diode est cliquable
    sprite(18).loc = point(18 + 28*(No-1 - 6*((No-1)/6)), 120 +30*((No-1)/6))--on place le triangle

  else--------------sinon on le fait disparaitre
    puppetSprite 18,FALSE
  end if
  updateStage
  --MAJ du logo de rubrique
  if zRacine() <> "COUR00" and  zRacine() <> "AIDE00"then
    sprite(1).member = "logo"&localparam("COORD",5)
  end if
  ------
  updatestage
  gL_Zap[3] = 0--on met α 0 le flag de mise α jour
  tell the stage
    put "Fin de la MAJ de la zapette"
  end tell
end
---------------------------------------------------------------------------------------------------------
on RAZ_Zap_params
  global gL_Zap
  gL_Zap = [EMPTY,0,0,[0,0],rect(0,0,0,0),rect(0,0,0,0),[],[],EMPTY,0,EMPTY,0,[0,0],0,0,\
[150,200,255,255,255,255,255,100,6],1,1,[],1,1,1,0,EMPTY,[0,0],rect(0,0,0,0),rect(0,0,0,0),0,[0,0],0]
  --1) nom de la fenΩtre zap
  --2) flag ouverture zapette
  --3) flag maj de la zapette
  --4) [largeur zapette, hauteur zapette]
  --5) rect de la fenΩtre zapette α sa premiΦre apparition
  --6) rect actuel de   la fenΩtre zapette
  --7) liste des pistes des boutons de navigation de la zapette
  --8) liste des pistes des boutons utilitaires de la zapette
  --9) label sous-module dans la fenΩtre zapette
  --10) flag de pause
  --11) dernier movie ouvert
  --12) flag de saisie de la barre de dΘplacement de la fenΩtre zapette
  --13) vecteur de dΘcalage entre le point de cette saisie et le coin HG de cette fenΩtre zap
  --14) n░ de piste du fond de la zapette
  --15) n░ de piste des diodes
  --16) liste des intensitΘs des pistes sons + niveau gΘnΘral(de 1 α 6)
  --17) flag de valide musique
  --18) flag de valide raccourcis
  --19) liste des pistes des boutons MISC de la zapette
  --20) flag d'interactivitΘ des diodes (par dΘfaut α 1); peut Ωtre modifiΘ par diode(u) o∙ vaut 1 ou 0
  --21) n░ piste bandeau du bas dans le dir principal(par dΘfaut α 1 mais mis α jour on beginsprite du bandeau
  --22) flag d'importation des textes locaux
  --23) flag d'ouverture fenΩtre commentaires
  --24) nom de la fenΩtre commentaires
  --25) dimensions de la fenΩtre commentaires
  --26) position initiale de la fenΩtre commentaires
  --27) position actuelle de la fenΩtre commentaires
  --28) flag mode de la fenΩtre commentaires
  --29) vecteur de dΘcalage entre le point de cette saisie et le coin HG de cette fenΩtre commentaires
  --30) flag de lancement de son commentaire α afficher
end
---------------------------
on prepare_Rub
  global glocal_Folder, gRacine, gL_mobiDATA, gL_localdata, gL_Zap, gL_sRubTitres
  global gL_localTEXTES
  if D10() then
    (the stage).appearanceOptions.mask = member("STAGE_MASK")
    (the stage).type = #document
  end if
  if voidP(gL_Zap) then RAZ_Zap_params()
  if gL_Zap[11] = "CPLU00" then
    Flagcoupegmusik = 0
  else
    coupeson(1)
    Flagcoupegmusik = 1
  end if
  repeat with i = 1 to 10
    temp = sprite(i).scriptList
    fin = count(temp)
    repeat with j = 1 to fin
      if temp[j][1].name contains "BANDEAU_MOBICLIC" then
        sprite(i).locZ = 3000 + i
        exit repeat
      end if
    end repeat
  end repeat
  --  the alertHook = script "ALERT_JLM"
  --1)--------------------------------------MAJ DES CHEMINS DE RECHERCHE DES FICHIERS--------------------
  the searchPaths = ["@//COMMUN","@//COMMUN/MUSIK"]
  --2)--------------------------------------MAJ DE LA LISTE DES PARAMETRES GENERAUX------------------------
  if voidP(gL_mobiDATA) then
    gL_mobiDATA =  gimmeDATA([2,4])--gL_mobiDATA = [paramΦtres du No actuel,liste des rubriques avec le n░ de famille,le nombre d'items dans zapette,le titre dans zapette]
    if D10() then
      gL_mobiDATA[1].add(_system.environmentPropList.getProp("osVersion"))--on ajoute l'OS et sa version
    else
      gL_mobiDATA[1].add("NOP")
    end if
    NbRub = count(gL_mobiDATA[2])-1
    gL_mobiDATA[1].add(NbRub)--on ajoute aux paramΦtres du no le nombre de rubriques y compris le sommaire (sauf l'intro, le courrier
    -- et l'aide mobiclic)
    L = []
    --    repeat with i = 1 to NbRub+1
    repeat with i = 1 to NbRub + 1
      L.add(string(gL_mobiDATA[2].getPropAt(i)).char[1..4])
    end repeat
    gL_mobiDATA.add(L)
    --crΘation de la liste de navigation de l'utilisateur
    L1 = []
    repeat with i = 1 to NbRub
      L2 = []
      u = i+1--dΘcalage α cause de l'intro qu'on ne compte pas
      fin = count(gimmeDATA([4 + 2*u])[1])-- car mobidata renvoie [[....]]); on compte le nombre d'Θcrans par rubrique
      repeat with j = 1 to  fin
        L2.add(0)
      end repeat
      L1.add(L2)
    end repeat
    gL_mobiDATA.add(L1)
    --gL_mobiDATA = [params du No actuel,liste des rubs avec n░ de famille, liste des noms gΘnΘriques des .dir des rubs,liste navigation]
    --MAJ du popMenu des rubriques dans la zapette------------------
    L_inactifs = gL_Mobidata[1][3]-- on extrait la liste des rubriques inactives du mois
    LtitresRoll = value(member("TITRES_ROLL_ZAPETTE").line[1])-- on extrait la liste des titres en roll des accΦs rubriques dans la zapette
    debut = 3-----------------------on exclut INTRO et RATOCLIC
    fin = count(gL_mobiDATA[2])-2 --on exclut COURRIER et AIDE
    ListeTitres = EMPTY-- on initialise la variable dans la quelle on va piler les libellΘs des accΦs rubriques pour le popMenu
    L3 = []--on initialise la liste des accΦs rubriques
    repeat with i = debut to fin
      zeprop = gL_mobiDATA[2].getpropAt(i)
      if L_inactifs.getPos(value(zeprop)) = 0 then
        Lvaleurs = gL_mobiDATA[2].getprop(zeprop)
        NbItems = Lvaleurs[2]--on lit le nombre d'items de la rubrique figurant dans le popMenu
        case(NbItems) of
          1:-- s'il n'y a qu'un seul point d'accΦs α la rubrique
            temp = Lvaleurs[3]
            tampon = LtitresRoll.getProp(zeprop)
            L3.add([string(zeprop),tampon])--on ajoute α la liste [le nom abrΘgΘ de celle-ci,le titre roll] (ex: [.....,["TOUT", "La pΩche α la sardine"]]
          otherwise:-- s'il y a plusieurs point d'accΦs α la rubrique
            temp = EMPTY
            u = Lvaleurs[3]
            repeat with j = 1 to NbItems
              tampon = LtitresRoll.getProp(zeprop&string(j))
              temp = temp&u&&string(j)
              L3.add([string(zeprop),j,tampon])--on ajoute α la liste le nom abrΘgΘ de celle-ci,le n░ d'accΦs,le titre roll] ex: [.....,["ARRIBA",2, "Le jeu du con"]]
              if j < NbItems then temp = temp&RETURN
            end repeat
        end case
        ListeTitres = ListeTitres&temp
        if i < fin then ListeTitres = ListeTitres&RETURN
      end if
    end repeat
    member("TITRES_RUBRIQUES").text = ListeTitres -- on remplit le popmenu
    gL_mobiDATA.add(L3)
    --gL_mobiDATA = [params du No actuel,liste des rubs avec n░ de famille, liste des noms gΘnΘriques des .dir des rubs,liste navigation,liste des acces rubriques du popmenu]
  end if
  --3)--------------------------------------MAJ DE LA LISTE DES PARAMETRES LOCAUX------------------------
  glocal_Folder = gimmeMyFolder()-- on extrait le nom du dossier courant
  temp = the movieName
  L = length(temp)
  gRacine = CLEANLOWCASE(temp.char[1..L-4])-- on extrait la partie utile du nom du fichier par exemple "BIDU02" dans "BIDUO2.dir"
  ABREV = gRacine.char[1..4]
  NoRub = gL_mobiDATA[3].getPos(ABREV)--on extrait le n0 de la rubrique dans la liste
  --par exemple "BIDU02.dir" fait partie de la 3Φme rubrique (dans la liste ["BACS", "BIBLIO", "BIDULE",.....]
  NomRub = gL_mobiDATA[2].getPropAt(NoRub)
  NoFamille = gL_mobiDATA[2].getprop(NomRub)[1]
  NoEcran = extractNo(gRacine) + 1 -- par exemple "BIDU00.dir" donne 0+ 1 => 1er movie de la rubrique
  temp = gimmeDATA([4 + 2*NoRub])[1]-- car mobidata renvoie [[....]]
  NbEcrans = count(temp)
  gL_localdata = temp[NoEcran]
  gL_localdata.addProp(#COORD,[NomRub,NoRub,NoFamille,NbEcrans,ABREV,NoEcran])
  -- on rajoute [la partie gΘnΘrique des noms des movies de la rubrique, le No de movie dans la rubrique, le n░ de la rubrique, sa famille, le nb de dir, le nom abrΘgΘ, le n░ de dir courant]]
  put "Fin de la MAJ des paramΦtres locaux du movie "&the movieName

  --4)--------------------------------------MAJ DE LA GESTION DE LA ZAPETTE-------------------------------

  if gRacine  = "RATO00" then--α l'ouverture du sommaire on force l'apparition de la zapette
    if gL_Zap[2] = 0 then
      show_zapette()
    else
      refresh_zapette
    end if
  else
    refresh_zapette
  end if
  --5)--------------------------------------MAJ DE LA GESTION LOCALE DES TOUCHES DE RACCOURCIS------------
  case(localParam("MISC","ZSHORTCUTS")) of
    1:
      touchesOn()
    -1:
      touchesOff()
  end case
  --6)---------------------------------------MAJ DE LA GESTION DU SON
  niveauSon()
  --7)---------------------------------------LANCEMENT DE LA MUSIQUE D'AMBIANCE---------------------------
  case(Flagcoupegmusik) of
    0:
      nothing
    1:
      fin = the number of members of castLib(1)
      temp = "MUSIK_"&gRacine
      repeat with i = 1 to fin
        if member(i).name = temp then
          puppetSound(1,"MUSIK_"&gRacine)
          exit repeat
        end if
      end repeat
  end  case
  --8)---------------------------------------MAJ DES TITRES BANDEAUX
  --  fin = the number of members of castLib(1)
  --  temp = "LOCAL_TITRES"
  --  repeat with i = 1 to fin
  --    if member(i).name = temp then
  --      gL_sRubTitres = []
  --      EOL = member("LOCAL_TITRES").line.count
  --      repeat with j = 1 to EOL
  --        gL_sRubTitres.add(member("LOCAL_TITRES").line[j])
  --      end repeat
  --      exit repeat
  --    end if
  --  end repeat

  --9)---------------------------------------MAJ DU FOND DE LA FENETRE COMMENTS SI ELLE A DEJA ETE OUVERTE
  if gL_Zap[23] <> 0 then-- si la fenΩtre est visible(1) ou invisible(-1)
    tell gL_Zap[24]
      sprite(1).member = "FD_COMMENT_"&gimme2digits(zfamily())
      updatestage
    end tell
  end if
  --10)-------------------------------------MAJ des containers en cas d'utilisation d'une DB d'utilisateurs
  if zNoSRub() = 1 then--si on dΘbute la rubrique ( XXXX00.dir)
    member("USER_SELECTION").text = EMPTY
    member("USERS_TANK").text = EMPTY
  end if
end
-----------------------------------------------------------------------------------------------------------
on close_Rub
  global gL_Zap, gRacine, gL_sRubTitres,gZ_pisteTitre
  --member("LOCAL_TEXTES").text = EMPTY
  inscription()
  gL_sRubTitres = VOID
  RAZ_pistes_son()
  temp = the windowlist.duplicate()--fermeture des fenΩtres locales
  if temp <> [] then
    N = count(temp)
    repeat with i = 1 to N
      nomfen = temp[i].name
      if tail(nomfen, 5) = "_TEMP"  then
        window(nomfen).close()
        window(nomfen).forget()
      end if
    end repeat
  end if
  if the runMode = "Author" then
    gL_Zap[1].close()
    gL_Zap[1].forget()
    gL_Zap[2] =0
    case(gL_Zap[23]) of
      -1:
        gL_Zap[24].forget()
      1:
        gL_Zap[24].close()
        gL_Zap[24].forget()
    end case
    gL_Zap[23] = 0
  end if
  gL_Zap[11] = gRacine
  gZ_pisteTitre = VOID
end
--------------------------
on inscription--permet de marquer la visite de ce dir dans la liste de navigation
  global gL_mobidata
  gL_mobidata[4][localparam("COORD",2)-1][localparam("COORD",6)] = 1--le "-1" car on ne liste pas l'intro
end
--------------------------
on gimmeDATA LISTE_LIGNES
  --ANCIENNE VERSION-----------------------------------------------------------------
  --  pipeLine = new(xtra"fileio")-- cration d'une instance de l'Xtra File IO
  --  temp = "@//COMMUN/DATABASE/MOBIDATA.txt"
  --  if not voidP(temp) and not (temp = EMPTY) then
  --    openFile(pipeLine, temp, 1)--ouverture du fichier
  --    if status(pipeLine) = 0 then
  --      tampon = readFile(pipeLine)
  --      reponse = []
  --      repeat with i in LISTE_LIGNES
  --        reponse.add(value(CLEANLOWCASE(tampon.line[i])))
  --      end repeat
  --    else
  --      alert error (pipeLine, status(pipeLine))
  --      reponse = [-1]
  --    end if
  --  end if
  --  closeFile(pipeLine)
  --  pipeLine = 0
  --NOUVELLE VERSION------------------------------------------------------------
  reponse = []
  repeat with i in LISTE_LIGNES
    --    reponse.add(value(CLEANLOWCASE(member("MOBIDATA").text.line[i])))
    reponse.add(value(member("MOBIDATA").text.line[i]))
  end repeat
  ------------------------------------------------------------------------------
  return reponse--ATTENTION RENVOI D'UNE LISTE DE LISTES
end
----------------
on CLEANLOWCASE CHAINE
  -- cette procΘdure permet de remplacer les minuscules par des majuscules dans une chaine de caractΦres
  reponse = EMPTY--on  remet la pile α zΘro
  FIN = length(CHAINE)
  repeat with i = 1 to FIN
    temp = CHAINE.char[i]
    u = chartoNum(temp)
    case(u>64 and u < 91) of
      1:---------c'est une lettre capitale
        reponse = reponse&temp--on la pile
      0:
        case(u>96 and u < 123) of
          1: ----------------c'est une bas de casse
            reponse = reponse&numtochar(u - 32)--on pile la majuscule correspondante
          0:-----------------ce n'est pas une lettre
            reponse = reponse&temp--on pile le caractΦre
        end case
    end case
  end repeat
  return reponse
end
-------------------
on diode N-- activation/dΘsactivation des diodes
  -- si N = 1 les diodes sont interactives, si 0 elles sont inhibΘes
  global gL_Zap
  gL_Zap[20] = N
end
----------------
on ZAP_NAVIG me, NoItem --gΦre la navigation par bouton dans la zapette
  global gL_Zap
  case(NoItem) of
    1,2:--SUITE, RETOUR,
      tell the stage
        goSameRub(localParam("NAV",NoItem))
      end tell
    3:--DEBUT
      temp =  localParam("NAV",NoItem)
      case(temp) of
        99:
          tell the stage
            goOtherRub("RATOCLIC",0, "ATTENTE")
          end tell
        otherwise:
          tell the stage
            goSameRub(temp)
          end tell
      end case
    4:--REJOUER
      tell the stage
        go movie("@/"&the movieName)
      end tell
    5:--PAUSE
      case(gL_Zap[10]) of
        0:
          sprite(me.spriteNum).member = "BTON_GO"
          tell the stage
            PAUSE()
          end tell
          gL_Zap[10] = 1
        1:
          sprite(me.spriteNum).member = "BTON_PAUSE"
          tell the stage
            go the frame-- cela dΘbloque la pause
          end tell
          gL_Zap[10] = 0
      end case
    6:--SOMMAIRE
      tell the stage
        goOtherRub("RATOCLIC",0, "ATTENTE")
      end tell
  end case
end
---------------
on ZAP_TOOLS NoItem--gΘre les outils d'aide dans la zapette
  global gL_Zap, gL_localTEXTES, gL_RetourAide
  case(NoItem) of
    1:--Aide rubrique locale
      tell the stage
        if voidP(gL_localTEXTES) then init_localTEXTES
        if gL_localTEXTES = [] then
          member("AIDE_RUB").text = EMPTY
        else
          temp = gL_localTEXTES.getaProp("_AIDE")
          member("AIDE_RUB").text = member(COMMENT_TANK()).char[temp[1]..temp[2]]
        end if
        member("AIDE_RUB").fontSize = 10
        member("AIDE_RUB").scrollTop = 0
      end tell
      case(gL_Zap[2]) of
        0:-- la zapette n'a jamais ΘtΘ ouverte
          show_zapette()
          tell gL_Zap[1]
            go "AIDE_"&gimme2digits(zfamily())
          end tell
        1:-- la zapette a dΘjΘ ΘtΘ ouverte et elle est visible
          tell gL_Zap[1]
            go "AIDE_"&gimme2digits(zfamily())
          end tell
        -1:-- la zapette a dΘjΘ ΘtΘ ouverte et elle est invisible
          gL_Zap[1].open()
          tell gL_Zap[1]
            go "AIDE_"&gimme2digits(zfamily())
          end tell
      end case
    2:--Dico
      tell the stage
        if voidP(gL_localTEXTES) then init_localTEXTES
        if gL_localTEXTES = []  then
          member("DICO").text = EMPTY
        else
          temp = gL_localTEXTES.getaProp("_DICO")
          member("DICO").text = member(COMMENT_TANK()).char[temp[1]..temp[2]]
        end if
        member("DICO").fontSize = 10
        member("DICO").scrollTop = 0
      end tell
      case(gL_Zap[2]) of
        0:-- la zapette n'a jamais ΘtΘ ouverte
          show_zapette()
          tell gL_Zap[1]
            go "DICO_"&gimme2digits(zfamily())
          end tell
        1:-- la zapette a dΘjΘ ΘtΘ ouverte et elle est visible
          tell gL_Zap[1]
            go "DICO_"&gimme2digits(zfamily())
          end tell
        -1:-- la zapette a dΘjΘ ΘtΘ ouverte et elle est invisible
          gL_Zap[1].open()
          tell gL_Zap[1]
            go "DICO_"&gimme2digits(zfamily())
          end tell
      end case
    3:--Info
      tell the stage
        if voidP(gL_localTEXTES) then init_localTEXTES
        if gL_localTEXTES = [] then
          member("INFO").text = EMPTY
        else
          temp = gL_localTEXTES.getaProp("_INFO")
          member("INFO").text = member(COMMENT_TANK()).char[temp[1]..temp[2]]
        end if
        member("INFO").fontSize = 10
        member("INFO").scrollTop = 0
      end tell
      case(gL_Zap[2]) of
        0:-- la zapette n'a jamais ΘtΘ ouverte
          show_zapette()
          tell gL_Zap[1]
            go "INFO_"&gimme2digits(zfamily())
          end tell
        1:-- la zapette a dΘjΘ ΘtΘ ouverte et elle est visible
          tell gL_Zap[1]
            go "INFO_"&gimme2digits(zfamily())
          end tell
        -1:-- la zapette a dΘjΘ ΘtΘ ouverte et elle est invisible
          gL_Zap[1].open()
          tell gL_Zap[1]
            go "INFO_"&gimme2digits(zfamily())
          end tell
      end case
    4:--Sous titrage
      tell the stage
        show_COMMENTS()
      end tell
    5:--Aide Zapette
      tell the stage
        gL_RetourAide = [string(zrub()),zNoSRub()]
        goOtherRub("AIDE",0)
      end tell
  end case
end
---------------------------------
on ZAP_MISC NoItem--gΘre les btons MISC dans la zapette
  global gL_Zap,gL_mobidata,gChoixrub
  case(NoItem) of
    1:--bouton Volume Up
      if gL_Zap[16][9] < 6 then
        step = gL_Zap[16][9] + 1
        sprite(gL_Zap[19][3]).member = "VU"&gimme2digits(step)
        updateStage
        calcul_nivson(step )
      end  if
    2:--bouton Volume Down
      if gL_Zap[16][9] > 1 then
        step = gL_Zap[16][9] - 1
        sprite(gL_Zap[19][3]).member = "VU"&gimme2digits(step)
        updateStage
        calcul_nivson(step )
      end  if
    3:--pisteVumΦtre
      nothing
    4:--bouton coupe musique
      case(gL_Zap[17]) of
        1: --la piste musique marche,onla dΘsactive
          gL_Zap[16][1] = -gL_Zap[16][1]
          gL_Zap[17] = -1
          sprite(gL_Zap[19][4]).member = "BTON_MUSIK_ON"
        -1:--la piste musique est dΘsactivΘe, on la rΘactive
          gL_Zap[16][1] = -gL_Zap[16][1]
          gL_Zap[17] = 1
          sprite(gL_Zap[19][4]).member = "BTON_MUSIK_OFF"
      end case
      tell the stage
        sound(1).volume = gL_Zap[16][1]
      end tell
      updateStage
    5:--bouton print
      tell the stage
        imprime()
      end tell
    6:--bouton screenshot
      go "EXPORTJPEG"
      u = the date
      mem = the itemDelimiter
      the itemDelimiter = "/"
      tampon = "Mobi"&string( zNoMobi())
      repeat with i = 1 to 2
        tampon = tampon&u.item[i]
      end repeat
      v = the time
      the itemDelimiter = ":"
      repeat with i = 1 to 2
        tampon = tampon&v.item[i]
      end repeat
      the itemDelimiter = mem

      exportEcran("DOCUMENTS",tampon)
    7:--bouton rubrique prΘcΘdente
      if voidP(gChoixrub) then gChoixrub = localparam("COORD",2)
      if gChoixrub > 2 then
        gChoixrub = gChoixrub - 1
      else
        gChoixrub = gL_mobidata[1][5] - 1
      end if
      temp = gL_mobidata[3][gChoixrub]
      u = string(gL_mobidata[2].getPropAt(gChoixrub))
      if gL_mobidata[1][3].getPos(u) > 0 then -- si la rubrique est dΘsactivΘe
        sprite(1).member = "logo"&temp&"_OFF"
      else
        sprite(1).member = "logo"&temp
      end if
      lowjingle(8,"temp","OUT")
      --      puppetTransition 12,2,1,TRUE
    8:--bouton rubrique suivante
      if voidP(gChoixrub) then gChoixrub = localparam("COORD",2)
      if gChoixrub < gL_mobidata[1][5] -1 then
        gChoixrub = gChoixrub + 1
      else
        gChoixrub = 2
      end if
      temp = gL_mobidata[3][gChoixrub]
      u = string(gL_mobidata[2].getPropAt(gChoixrub))
      if gL_mobidata[1][3].getPos(u) > 0 then -- si la rubrique est dΘsactivΘe
        sprite(1).member = "logo"&temp&"_OFF"
      else
        sprite(1).member = "logo"&temp
      end if
      lowjingle(8,"temp","OUT")
      --      puppetTransition 11,2,1,TRUE
    9:-- bouton quitter
      tell the stage
        go movie "@//COMMUN/GENERIC"
      end tell
  end case
end
----------
on gimmeMyFolder
  temp = the pathName
  n1 = offset("DATA", temp) + 5
  n2 = length(temp) - 1
  return temp.char[n1..n2]
end
---------------------
on compte_Mots()
  Nb_acteurs = the number of members of castLib 1
  compteur = 0
  repeat with i = 1 to Nb_acteurs
    ZENOM = member(i).name
    if ZENOM contains "MOT" and not(ZENOM contains "_R") and not(ZENOM contains "_S") and not(ZENOM contains "_I") then
      L = length(ZENOM)
      ZENo = value(ZENOM.char[L-1..L])
      compteur = max(compteur, ZENo)
    end if
  end repeat
  return compteur
end
-------------
on clic_zap ZETARGET, ZESOUNDTRACK
  puppetSound ZESOUNDTRACK, 0
  go ZETARGET
end
-------------------
on printCropEcran ZERECT
  member("TAMPON_ECRAN").image = the stage.image
  crop(member("TAMPON_ECRAN"), ZERECT)
  --  imprimeacteur(member("TAMPON_ECRAN").memberNum,member("TAMPON_ECRAN").castlibNum)
  printFrom label("PRINT_LABEL")
end
-------------------
on exportPicture ACTEUR, CHEMIN
  temp = member(ACTEUR).image
  SaveAsJPEG(temp,CHEMIN,100)
end
------------------
on exportEcran TARGET,NOMFIC
  member("TAMPON_ECRAN").picture = the stage.picture
  pipeline = xtra(XtraVersion("FILEXTRA")).new()
  case(TARGET) of
    "BUREAU":
      case(lien()) of
        ":":
          localpath = pipeline.fx_FolderGetSpecialPath("kDesktopFolderType")
        "\":
          localpath = pipeline.fx_FolderGetSpecialPath("CSIDL_COMMON_DESKTOPDIRECTORY")
        otherwise:
          beep 2
      end case
    "DOCUMENTS":
      case(lien()) of
        ":":
          localpath = pipeline.fx_FolderGetSpecialPath("kDocumentsFolderType")
        "\":
          localpath = pipeline.fx_FolderGetSpecialPath("CSIDL_PERSONAL")
        otherwise:
          beep 2
      end case


  end case
  exportPicture("TAMPON_ECRAN",localpath&NOMFIC&".jpg")
  pipeline = 0
end
--------------------------
on faire_bonne_impression  WATMODE, WATTYPE,WATSTUFF,TITRE, PIED_DE_PAGE
  -- WATMODE indique si on est en mode aperτu (1) ou en mode impression (0)
  -- WATMEDIA indique le type de fichier α imprimer : acteur (nom d'acteur) ou Θcran ("E")
  -- crΘation d'une instance de l'xtra d'impression----------------------------------------------------------
  doc = new(xtra "PrintOMatic")
  if not objectP(doc) then exit
  -- rΘglages des marges
  setPrintableMargins (doc)
  setMargins doc, rect(42,42,42,42)
  -- crΘation de la page
  if (doPageSetup(doc)) then
    newPage doc
    -- initialisation des variables de format page
    L_Page=getPageWidth(doc)
    H_Page=getPageHeight(doc)
    --initialisation de la police
    setTextFont doc,"Dream of me *"

    case(WATTYPE) of
      "E": --impression d'Θcran

      "M":--impression d'acteur
        L = float(member(WATSTUFF).width)
        H = float(member(WATSTUFF).height)
        coef  = H/L
        case(L>=H) of
          1:
            L_schema = min(L, L_Page)
            H_schema = (L_schema)*coef
          0:
            H_schema = min(H,H_Page-50)
            L_schema = H_schema/coef
        end case
        drawPicture doc,member(WATSTUFF),rect(0,0,L_schema,H_schema)
        ----------------- PIED DE PAGE -------------------
        -- ligne horizontale bas de page
        --        drawLine doc,point(0,H_Page-30),point(L_Page,H_Page-30)
        setTextJust doc,"left"
        setTextStyle doc,"plain"
        setTextSize doc,16
        drawText doc,PIED_DE_PAGE,point(L_Page- 255,H_Page-15)
        -- logo  GF
        --        drawPicture doc,member("LOGO_MILAN"),rect(L_Page- 41,H_Page-41,L_Page-1,H_Page-1)
        setTextSize doc,8
    end case
    -- lancement de l'impression-----------------------------------------------------------
    case(WATMODE) of
      1:-- si on est en mode aperτu on affiche l'aperτu
        printPreview doc
      0:-- sinon on imprime
        setProgressMsg doc, "Impression de la fiche "&TITRE&" en cours... "
        if doJobSetup(doc) then print doc
    end case
  end if
end
-----------------------------------
on faire_bonne_impression2  WATMODE, WATTYPE,WATSTUFF
  -- WATMODE indique si on est en mode aperτu (1) ou en mode impression (0)
  -- crΘation d'une instance de l'xtra d'impression----------------------------------------------------------
  doc = new(xtra "PrintOMatic")
  if not objectP(doc) then exit
  -- rΘglages des marges
  setPrintableMargins (doc)
  setMargins doc, rect(42,42,42,42)
  -- crΘation de la page
  if (doPageSetup(doc)) then
    newPage doc
    -- initialisation des variables de format page
    L_Page=getPageWidth(doc)
    H_Page=getPageHeight(doc)
    case(WATTYPE) of
      "E": --impression d'Θcran

      "M":--impression d'acteur
        L = float(member(WATSTUFF).width)
        H = float(member(WATSTUFF).height)
        coef  = H/L
        case(L>=H) of
          1:
            L_schema = max(L, L_Page-42)
            H_schema = (L_schema)*coef
          0:
            H_schema = max(H,H_Page-42)
            L_schema = H_schema/coef
        end case
        drawPicture doc,member(WATSTUFF),rect(0,0,L_schema,H_schema)
    end case
    -- lancement de l'impression-----------------------------------------------------------
    case(WATMODE) of
      1:-- si on est en mode aperτu on affiche l'aperτu
        printPreview doc
      0:-- sinon on imprime
        setProgressMsg doc, "Impression en cours... "
        if doJobSetup(doc) then print doc
    end case
  end if
end
------------------------------------------------------------------------------
on compte_Famille RACINE_NOM, NoDISTRIB
  case(the paramCount) of
    1:
      Nb_acteurs = the number of members of castLib 1
    2:
      Nb_acteurs = the number of members of castLib NoDISTRIB
  end case

  reponse = 0
  repeat with i = 1 to Nb_acteurs
    if member(i,NoDISTRIB).name contains RACINE_NOM then
      reponse = reponse + 1
    end if
  end repeat
  return reponse
end
--------------------
on RAZ_pistes_son
  repeat with i = 2 to 8
    coupeson(i)
  end repeat
  -------------------
on gimmezeDroite ZE2POINTS
  x1 = ZE2POINTS[1][1]
  y1 = ZE2POINTS[1][2]
  x2 = ZE2POINTS[2][1]
  y2 = ZE2POINTS[2][2]
  if abs(x1-x2) < 2 then
    x2 = x1
  else
    if abs(y1-y2) < 2 then
      y2 = y1
    end if
  end if
  case(x1<>x2 and y1 <> y2) of
    1:
      -- cas gΘnΘral
      a = float(y2 - y1)/(x2 - x1)
      b = y1 - a*x1
      reponse = [a,b]
    0:
      case(x1 = x2) of
        1: --droite verticale

          reponse = ["V", x1]
        0: -- droite horizontale
          reponse = ["H", y1]
      end case
  end case
  return reponse
end
---------------------
on extractNo LIBELLE
  --pour un libellΘ de la forme TRUC_ii o∙ ii est un indice α 2 chiffres, renvoie l'indice
  --ex "MOBI_07" -> 7
  L = length(LIBELLE)
  reponse = value(LIBELLE.char[L-1..L])
  return reponse
end
--------------------
on extractRoot LIBELLE
  --pour un libellΘ de la forme TRUC_ii o∙ ii est un indice α 2 chiffres, renvoie la racine
  --ex "MOBI_07" -> "MOBI"
  --sinon renvoie le libellΘ
  L = length(LIBELLE)
  if not(voidP(extractNo(LIBELLE))) and LIBELLE.char[L-2] = "_" then
    return LIBELLE.char[1..L-3]
  else
    return LIBELLE
  end if
end
--------------------
on localdata
  case(the paramCount) of
    1:
      return value(member("localdata").line[param(1)])
    2:
      if param(1) = 0 or param(2) =0 then
        return EMPTY
      else
        if param(2) < param(1) then
          return EMPTY
        else
          reponse = []
          repeat with i = param(1)  to param(2)
            reponse.add(value(member("localdata").line[i]))
          end repeat
          return reponse
        end if
      end if
  end case
end
-----------------------
on jump_intro ZEGOUDLABEL
  global L_gmemPassage
  if L_gmemPassage = VOID then L_gmemPassage = []
  zemoovy_nem = the movieName.char[1..length(the movieName)-4]
  if L_gmemPassage.getPos(zemoovy_nem) > 0 then
    go ZEGOUDLABEL
    spritesMenus()
    hide_title()
  else
    L_gmemPassage.add(zemoovy_nem)
  end if
end
---------------------
on gere_soustitrage ID_SON-- procΘdure lancΘe dans les procΘdures "joueson()"
  global gL_localTEXTES, gL_Zap
  if zDumb() = -1 then
    member("DUMB_COMMENT").text = EMPTY
  else
    if voidP(gL_localTEXTES) then
      init_localTEXTES()
    else
      if gL_localTEXTES = 0 then--cas o∙ l'acteur "LOCAL_TEXTES n'a pas ΘtΘ crΘΘ
        exit
      else
        member("DUMB_COMMENT").text = trouve_soustitre(ID_SON)
        if gL_Zap[23] <> 0 then
          tell gL_Zap[24]
            member("DUMB_COMMENT_BIS").text =  member("DUMB_COMMENT").text
          end tell
        end if
      end if
    end if
  end if
end
-----------------------
on init_localTEXTES
  global gL_localTEXTES
  fin = the number of members of castLib(1)
  flag = 0
  test =  COMMENT_TANK()
  repeat with i = 1 to fin
    if member(i).name = test then
      flag = i
      L = member(test).line.count
      gL_localTEXTES = value(member(test).line[L])
      exit repeat
    end if
  end repeat
  if flag = 0 then gL_localTEXTES = []

end
--------------
on sonrub SON, Nopiste
  joueson(localparam("COORD",5)&gimme2digits(localparam("COORD",6)-1)&"_"&SON)
  if the paramCount = 2 then joueson(localparam("COORD",5)&gimme2digits(localparam("COORD",6)-1)&"_"&SON, Nopiste)
end
----------------------
on trouve_soustitre CHAINE
  global gL_localTEXTES
  if gL_localTEXTES <> [] then
    temp = gL_localTEXTES.getaProp(CLEANLOWCASE(CHAINE))
  else
    temp = VOID
  end if
  if voidP(temp) then
    return EMPTY
  else
    return member(COMMENT_TANK()).char[temp[1]..temp[2]]
  end if
end
---------------------------------------------------------
on calculNolineaire ZELISTE,NoSOUSLISTE, NoELEMENTSOUSLISTE
  --dans une liste de listes renvoie le n░ linΘaire d'un ΘlΘment d'une des sous-listes
  temp = 0
  repeat with i = 1 to NoSOUSLISTE-1
    temp = temp + count(ZELISTE[i])
  end repeat
  return temp + NoELEMENTSOUSLISTE
end
---------------------------------------------
on matrix2list NoLIGNE,NoCOLONNE, NbCOLONNES
  if NoLIGNE < 1 or NoCOLONNE < 1 or NoCOLONNE > NbCOLONNES then
    return -1
  else
    return (NoLIGNE -1)*NbCOLONNES + NoCOLONNE
  end if
end
---------------------------------------
on list2matrix No,NbCOLONNES
  Q = No/ NbCOLONNES
  R = No - Q*NbCOLONNES
  case(No) of:
    0:
      return [0,0]
    otherwise:
      case(R) of
        0:
          return [Q, NbCOLONNES]
        otherwise:
          return [Q + 1, R]
      end case
  end case
end
---------------------------------------
on moyennepond-- en paramΦtres: des listes [valeur,population associΘe]
  fin = the paramCount
  tot = 0
  totcardinal = 0
  repeat with i = 1 to fin
    L= param(i)
    tot = tot + L[1]*L[2]
    totcardinal = totcardinal + L[2]
  end repeat
  return float(tot)/totcardinal
end
---------------------------------
on peakzeLOOP SPRITENo, WATMODE
  case(WATMODE) of
    "M":
      temp = sprite(SPRITENo).member.name
      Nopiste = extractNo(temp)
      tell sprite(SPRITENo)
        if sprite(Nopiste) .member.number > 0 then
          return sprite(Nopiste).member.name
        else
          return "NOP"
        end if
      end tell
    "S":
      --nothing
  end case
end
------------------
on listshake ZELIST -- donne une combinaison alΘatoire d'une liste
  Nb_Items = count(ZELIST)
  L_random = randomList(Nb_Items, Nb_Items)
  L_reponse = []
  repeat with i = 1 to Nb_Items
    L_reponse.add(ZELIST[L_random[i]])
  end repeat
  return L_reponse
end
------------
on FIC2MEMBER FICPATH,NOMFICHIER,NOMACTEUR
  pipeLine = new(xtra"fileio")-- crΘation d'une instance de l'Xtra File IO
  temp = FICPATH&NOMFICHIER
  -- test  fichier valide
  if not voidP(temp) and not (temp = EMPTY) then
    openFile(pipeLine, temp, 1)--ouverture du fichier
    if status(pipeLine) = 0 then
      temp = readFile(pipeLine)
      member(NOMACTEUR).text = temp
    else
      alert error (pipeLine, status(pipeLine))
    end if
  end if
  closeFile(pipeLine)
  pipeLine = 0
end
--------------------------------------------------
on MEMBER2FIC FICPATH,NOMFICHIER,NOMACTEUR
  pipeLine = new(xtra"fileio")-- crΘation d'une instance de l'Xtra File IO
  --
  fileName = FICPATH&NOMFICHIER
  -- crΘe le fichier
  createFile (pipeLine, filename)
  -- ouvre le fichier
  openFile (pipeLine, filename, 0)
  --dΘtruit le fichier deja existant
  delete(pipeLine)
  -- crΘe le fichier
  createFile (pipeLine, filename)
  -- ouvre le fichier
  openFile (pipeLine, filename, 0)
  -- Θcriture de l'acteur
  pipeLine.writeString(member(NOMACTEUR).text)
  -- fermeture
  closeFile(pipeLine)
  pipeLine = 0
end
--------------------------------------
on MAJ_userlist MODE,MAX
  global gNb_users
  member("USERS_LIST").text = EMPTY
  case (member("USERS_TANK").text = EMPTY) of
    1:------------------------------ si le container est vide
      gNb_users = 0
      member("USERS_LIST").text = EMPTY
    0:------------------------------ si le container n'est pas vide
      the floatPrecision = 2
      gNb_users = member("USERS_TANK").line.count
      case(the paramCount) of
        0:--aucun paramΦtre, par dΘfaut α la maniΦre du QUIZ--------------------------------------------
          repeat with i = 1 to  gNb_users
            temp = value(member("USERS_TANK").line[i])
            temp1 = temp[1]
            temp2 = float(temp[2][1])/temp[2][2]
            if temp2 = 10.00 then
              the floatPrecision = 0
              member("USERS_LIST").line[i] = temp1&TAB&string(temp2*10)&&"%"
              the floatPrecision = 2
            else
              the floatPrecision = 2
              member("USERS_LIST").line[i] = temp1&TAB&string(temp2*10)&&"%"
            end if
          end repeat
        1:--1 paramΦtre
          case(MODE) of
            "NOP":--on affiche seulement le nom suivi du rΘsultat brut
              repeat with i = 1 to  gNb_users
                temp = value(member("USERS_TANK").line[i])
                temp1 = temp[1]
                temp2 = temp[2][1]
                member("USERS_LIST").line[i] = temp1&TAB&string(temp2)
              end repeat
            "B":--on affiche les meilleurs scores
              repeat with i = 1 to  gNb_users
                temp = value(member("USERS_TANK").line[i])
                temp1 = temp[1]
                temp2 = temp[2][5]--meilleur score actuel
                temp3 = temp[2][1]--score de la partie
                zebest = max(temp2,temp3)
                member("USERS_LIST").line[i] = temp1&TAB&string(temp2)
              end repeat
            otherwise:

          end case
        2:--2 paramΦtres
          case(MODE) of:
            "SURCENT":--------en pourcentage sur l'ensemble des joueurs
              repeat with i = 1 to  gNb_users
                temp = value(member("USERS_TANK").line[i])
                temp1 = temp[1]
                temp2 = temp[2][1]*100/MAX
                member("USERS_LIST").line[i] = temp1&TAB&string(temp2)&"/100"
              end repeat
          end case
      end case
  end case
end
------------
on gimme_userList USER_FIC,CONTAINER
  global glocalBUpath
  case(lien()) of
    ":":
      pipeline = xtra(XtraVersion("FILEXTRA")).new()
      glocalBUpath = pipeline.fx_FolderGetSpecialPath("kDocumentsFolderType")
    "\":
      pipeline = xtra(XtraVersion("FILEXTRA")).new()
      --      glocalBUpath = baSysFolder("desktop")
      glocalBUpath = pipeline.fx_FolderGetSpecialPath("CSIDL_PERSONAL")
  end case

  ------------------------- on teste la prΘsence du dossier des datas des MOBICLIC
  temp = pipeline.Fx_FolderExists(glocalBUpath&"MOBICLIC")
  case(temp) of
    1:-- si le dossier existe on teste la prΘsence du fichier utilisateur actuel
      temp = pipeline.Fx_FileExists(glocalBUpath&"MOBICLIC"&lien()&USER_FIC&".txt")
      case(temp) of
        1:--si le fichier utilisateur existe on le charge
          FIC2MEMBER(glocalBUpath&"MOBICLIC"&lien(),USER_FIC&".txt",CONTAINER)
        0:--s'il n'existe pas on le crΘe vierge
          temp = pipeline.Fx_FileCopy(the moviepath&lien()&"TEMPLATE.txt",glocalBUpath&"MOBICLIC"&lien()&USER_FIC&".txt")
          FIC2MEMBER(glocalBUpath&"MOBICLIC"&lien(),USER_FIC&".txt",CONTAINER)
      end case
    0:-- si le dossier n'existe pas on le crΘe ainsi que le fichier user vierge
      temp = pipeline.Fx_FolderCreate(glocalBUpath&"MOBICLIC")
      temp = pipeline.Fx_FileCopy(the moviepath&lien()&"TEMPLATE.txt",glocalBUpath&"MOBICLIC"&lien()&USER_FIC&".txt")
      FIC2MEMBER(glocalBUpath&"MOBICLIC"&lien(),USER_FIC&".txt",CONTAINER)
  end case
  pipeline  = 0
end
--------------------
on test_user
  global gNb_users, gUserName
  flag = 0
  repeat with i = 1 to gNb_users
    if  value(member("USERS_TANK").line[i])[1] = gUserName then
      flag = 1
      exit repeat
    end if
  end repeat
  case(flag) of
    0:-- si le nom n'a pas dΘja ΘtΘ utilisΘ
      return "OK"
    1:--si le nom a dΘja ΘtΘ utilisΘ
      return "KO"
  end case
end
----------------------------------------
on delete_user MODE
  global gNb_users, gNo_item, glocalBUpath,gScore_NomFic
  L = []
  repeat with i = 1 to gNb_users
    if i <> gNo_item then L.add(value(member("USERS_TANK").line[i]))
  end repeat
  member("USERS_LIST").text = EMPTY
  member("USERS_TANK").text = EMPTY
  if L <> [] then
    fin = count(L)
    repeat with i = 1 to fin
      if i = 1 then
        member("USERS_TANK").text = string(L[1])
        member("USERS_LIST").text = string(L[1][1])
      else
        member("USERS_TANK").text = member("USERS_TANK").text&RETURN&string(L[i])
        member("USERS_LIST").text = member("USERS_LIST").text&RETURN&string(L[i][1])
      end if
    end repeat
  end if
  gNb_users = gNb_users -1
  --enregistrement de la modif sur le disque dur
  case(the paramCount) of
    0:
      MEMBER2FIC(glocalBUpath&"MOBICLIC"&lien(),"M"&string(zNoMobi())&string(zRub())&".txt","USERS_TANK")
    1:
      case(param(1)) of
        "SCORE":
          MEMBER2FIC(glocalBUpath&"MOBICLIC"&lien(),gScore_NomFic&".txt","USERS_TANK")
        otherwise:
      end case
  end case
end
----------------------------------
on save_rubrik USER_FIC ,CONTAINER, NOM, STUFF2RECORD
  global  gNb_users, glocalBUpath
  N = 0
  case(member(CONTAINER).text = EMPTY) of
    1:
      member(CONTAINER).text = string([NOM, STUFF2RECORD])
    0:
      repeat with i = 1 to gNb_users
        if  value(member(CONTAINER).line[i])[1] = NOM then
          N = i
          exit repeat
        end if
      end repeat
      case(N) of
        0:
          member(CONTAINER).line[gNb_users + 1] = string([NOM, STUFF2RECORD])
        otherwise:
          member(CONTAINER).line[N] = string([NOM, STUFF2RECORD])
      end case
  end case
  MEMBER2FIC(glocalBUpath&"MOBICLIC"&lien(),USER_FIC&".txt",CONTAINER)
end
----------------------
on MAJ_SCORE NOM, LIST2SAVE,MODE
  global gScore_NomFic,gModeScore
  -----------------------------on sauvegarde les paramΦtres joueurs
  case(the paramCount) of
    2:--ancienne mΘthode(1fichier par RUBRIQUE pour un numΘro)
      save_rubrik("M"&string(zNoMobi())&string(zRub()) ,"USERS_TANK",NOM,LIST2SAVE)
    3:-------------------------nouvelle mΘthode(1fichier par SOUS_RUBRIQUE pour un numΘro)
      save_rubrik(gScore_NomFic,"USERS_TANK",NOM,LIST2SAVE)
  end case
  zRub_UserList("SCORE") -- on recharge les paramΦtres joueurs
  case(the paramCount) of
    2:
      MAJ_Userlist() -- on met α jour la liste des joueurs et leurs scores
    3:
      MAJ_Userlist(MODE)
  end case
end
-----------------------
on XtraVersion XTRANAME
  case(XTRANAME) of
    "FILEXTRA":
      case(lien()) of
        ":":
          return "FileXtra4"
        "\":
          return "FileXtra4"
      end case
    otherwise
      --
  end case
end
-----------
on creationRepertoires
  rdm = field "repDuMois"
  case the machineType of
    256 : -- la machine est un PC --------------------------------------------------------
      repertoire = baSysFolder("windows") & "MilanPresse"
      OK = baFolderExists(repertoire)
      if OK=0 then
        -- toute l'arborescence doit Ωtre crΘΘe
        baCreateFolder(repertoire)
        repMilan = the PathName & "Install\MilanPresse"
        XCopyDirectory(repMilan,repertoire)
      else
        -- le rΘpertoire Mobiclic est-il prΘsent ?
        repertoire = baSysFolder("windows") & "MilanPresse\Mobiclic"
        OK = baFolderExists(repertoire)
        if OK=0 then
          baCreateFolder(repertoire)
          repMobi = the PathName & "Install\MilanPresse\Mobiclic"
          XCopyDirectory(repMobi,repertoire)
        else
          -- le rΘpertoire du mois est-il prΘsent ?
          repertoire = baSysFolder("windows") & "MilanPresse\Mobiclic\" & rdm
          OK = baFolderExists(repertoire)
          if OK=0 then
            -- crΘation du rΘpertoire du mois
            repertoire = baSysFolder("windows") & "MilanPresse\Mobiclic"
            repMilan = the PathName & "Install\MilanPresse\Mobiclic"
            XCopyDirectory(repMilan,repertoire)
          end if
        end if
      end if

    otherWise : -- la machine est un Mac -------------------------------------------------
      repertoire = baSysFolder("prefs") & "MilanPresse"
      OK = baFolderExists(repertoire)
      if OK=0 then
        -- toute l'arborescence doit Ωtre crΘΘe
        baCreateFolder(repertoire)
        repMilan = the PathName & "Install:MilanPresse"
        XCopyDirectory(repMilan,repertoire)
      else
        -- le rΘpertoire Mobiclic est-il prΘsent ?
        repertoire = baSysFolder("prefs") & "MilanPresse:Mobiclic"
        OK = baFolderExists(repertoire)
        if OK=0 then
          baCreateFolder(repertoire)
          repMobi = the PathName & "Install:MilanPresse:Mobiclic"
          XCopyDirectory(repMobi,repertoire)
        else
          -- le rΘpertoire du mois est-il prΘsent ?
          repertoire = baSysFolder("prefs") & "MilanPresse:Mobiclic:" & rdm
          OK = baFolderExists(repertoire)
          if OK=0 then
            -- crΘation du rΘpertoire du mois
            repertoire = baSysFolder("prefs") & "MilanPresse:Mobiclic"
            repMilan = the PathName & "Install:MilanPresse:Mobiclic"
            XCopyDirectory(repMilan,repertoire)
          end if
        end if
      end if
  end case
end
----------------------------
on miseAtaille NOPISTE,IMAGE, WMAX, HMAX
  W = member(IMAGE).width
  H = member(IMAGE).height
  if W < WMAX and H < HMAX then
    sprite(NOPISTE).member = IMAGE
    sprite(NOPISTE).width = W
    sprite(NOPISTE).height = H
  else
    if W >H then
      k = W/float(H)
      H1 = WMAX/k
      if H1 <= HMAX then
        wfinal = WMAX
        hfinal = H1
      else
        hfinal = HMAX
        wfinal = HMAX*k
      end if
      sprite(NOPISTE).member = IMAGE
      sprite(NOPISTE).width = wfinal
      sprite(NOPISTE).height = hfinal
    else
      k = H/float(W)
      W1 = HMAX/k
      if W1 <= WMAX then
        wfinal = W1
        hfinal = HMAX
      else
        wfinal = WMAX
        hfinal = WMAX*k
      end if
      sprite(NOPISTE).member = IMAGE
      sprite(NOPISTE).width = wfinal
      sprite(NOPISTE).height = hfinal
    end if
  end if
  tds(NOPISTE,"ON")
end

-------------------------------------------
on miseAtailleSTAMP NOPISTE,IMAGE, WMAX, HMAX
  W = member(IMAGE).width
  H = member(IMAGE).height
  if W < WMAX and H < HMAX then
    sprite(NOPISTE).member = IMAGE
  else
    if W >H then
      k = W/float(H)
      H1 = WMAX/k
      if H1 <= HMAX then
        wfinal = WMAX
        hfinal = H1
      else
        hfinal = HMAX
        wfinal = HMAX*k
      end if
      sprite(NOPISTE).member = IMAGE
      sprite(NOPISTE).width = wfinal
      sprite(NOPISTE).height = hfinal
    else
      k = H/float(W)
      W1 = HMAX/k
      if W1 <= WMAX then
        wfinal = W1
        hfinal = HMAX
      else
        wfinal = WMAX
        hfinal = WMAX*k
      end if
      sprite(NOPISTE).member = IMAGE
      sprite(NOPISTE).width = wfinal
      sprite(NOPISTE).height = hfinal
    end if
  end if

end
--------------------------------